{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Function encoders with neural ODE basis functions\n",
    "The function encoder is agnostic to the basis function, so long as it is differentiable. Consequently, the basis function architecture can be modified to fit the problem at hand. For example, for continuous-time systems, the best models are typically neural ODEs. Neural ODEs output the gradient of the system, and then integrate it to get the next state, rather than outputing the next state directly:\n",
    "\n",
    "$$\n",
    "x_t = x_0 + \\int_0^t f(x_\\tau ; \\theta) d\\tau\n",
    "$$\n",
    "\n",
    "This is extremely accurate because the inductive bias of this model matches the continuous-time nature of the dynamical system. However, neural ODEs are slow to train, and cannot adapt to new data at runtime. We can fix this by combining neural ODEs with function encoders. As we saw in the [first example](Part_1_Intro_to_Function_Encoders.ipynb), function encoders can adapt their model estimates based on small amounts of data. By combining the two approaches, we get the best of both worlds: Accurate, continuous-time estimates AND efficient, online model updates. All this requires is to define the basis functions as neural ODEs instead of neural networks. The algorithm is unchanged.\n",
    "\n",
    "We will demonstrate this on a simple Van Der Pol system, modeled with a simple RK4 integrator."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Install Neuromancer (Colab only)"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "!pip install neuromancer"
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from neuromancer.dataset import DictDataset\n",
    "from neuromancer.dynamics import integrators\n",
    "from neuromancer.dynamics.integrators import Integrator\n",
    "from neuromancer.modules import blocks\n",
    "from neuromancer.system import Node\n",
    "from neuromancer.constraint import variable\n",
    "from neuromancer.loss import PenaltyLoss\n",
    "from neuromancer.problem import Problem\n",
    "from neuromancer.trainer import Trainer\n",
    "from tqdm import trange\n",
    "\n",
    "from neuromancer.modules.function_encoder import FunctionEncoder\n",
    "\n",
    "def vanderpol(state, mu):\n",
    "    \"\"\"The Van Der Pol mapping from x to \\dot x for a given value \\mu. \"\"\"\n",
    "    x1 = state[..., 0]\n",
    "    x2 = state[..., 1]\n",
    "    dx1 = x2\n",
    "    dx2 = mu * (1 - x1 ** 2) * x2 - x1\n",
    "    return torch.stack([dx1, dx2], dim=-1)\n",
    "\n",
    "def rk4_delta_only(model, state, dt):\n",
    "    \"\"\"\n",
    "    Integrate a model using the 4th order Runge-Kutta method.\n",
    "    :param model: a callable mapping from x to \\dot x\n",
    "    :param state: The initial state\n",
    "    :param dt:  The time horizon\n",
    "    :return: Delta X, the change in state\n",
    "    \"\"\"\n",
    "    k1 = model(state)\n",
    "    k2 = model(state + dt / 2 * k1)\n",
    "    k3 = model(state + dt / 2 * k2)\n",
    "    k4 = model(state + dt * k3)\n",
    "    return dt / 6 * (k1 + 2 * k2 + 2 * k3 + k4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's create some datasets. There is a design choice we can make here. We can either sample random states, and integrate them for a full trajectory, or we can integrate them for a single timestep. Integrating a full trajectory is a more realistic setting, but is also more challenging. Because Van Der Pol has an attractor, most of the data will end up at the attractor. Consequently, our data will be sparse elsewhere, and the learned model will be less accurate away from the attractor. In either case, we will still evaluate on full trajectory rollouts. For the sake of simplicity, this example samples random states. However, feel free to change the second from the bottom line in the following code block to test the other method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "dt = 0.05\n",
    "def create_dataset(device='cpu', generate_trajectory = False):\n",
    "\n",
    "    # hyper parameters\n",
    "    n_functions = 1000\n",
    "\n",
    "\n",
    "    # input space for sampling\n",
    "    input_low = torch.tensor([-4., -4.], device=device)\n",
    "    input_high = torch.tensor([4., 4.], device=device)\n",
    "    mu_range = torch.tensor([0.1, 3.], device=device)\n",
    "\n",
    "    # samples dynamical systems\n",
    "    mus = torch.rand(n_functions, 1, device=device) * (mu_range[1] - mu_range[0]) + mu_range[0]\n",
    "\n",
    "    # we can generate a series of trajectories with different values of mu.\n",
    "    # However, this makes the problems harder because Van Der Pol specifcally has an attractor\n",
    "    # this means the states will not be evenly distributed throughout the input space.\n",
    "    if generate_trajectory:\n",
    "        time_horizon = 1000\n",
    "        # Generate a trajectory of example data for each mu\n",
    "        initial_states = torch.rand(n_functions, 1, 2, device=device) * (input_high - input_low) + input_low\n",
    "        example_states = [initial_states]\n",
    "        for i in range(time_horizon):\n",
    "            current_state = example_states[-1]\n",
    "            delta_X = rk4_delta_only(lambda x: vanderpol(x, mus), current_state, dt)\n",
    "            new_state = current_state + delta_X\n",
    "            example_states.append(new_state)\n",
    "        example_states = torch.cat(example_states, dim=1)\n",
    "\n",
    "        # Generate a trajectory of query data for each mu\n",
    "        initial_states = torch.rand(n_functions, 1, 2, device=device) * (input_high - input_low) + input_low\n",
    "        query_states = [initial_states]\n",
    "        for i in range(time_horizon):\n",
    "            current_state = query_states[-1]\n",
    "            delta_X = rk4_delta_only(lambda x: vanderpol(x, mus), current_state, dt)\n",
    "            new_state = current_state + delta_X\n",
    "            query_states.append(new_state)\n",
    "        query_states = torch.cat(query_states, dim=1)\n",
    "\n",
    "        # now create the dataset for the function encoder. The input is a state x, the output is the delta x\n",
    "        example_xs = example_states[:, :-1, :]\n",
    "        example_delta_xs = example_states[:, 1:, :] - example_states[:, :-1, :]\n",
    "        query_xs = query_states[:, :-1, :]\n",
    "        delta_xs = query_states[:, 1:, :] - query_states[:, :-1, :]\n",
    "\n",
    "\n",
    "        dataset = {\"example_xs\": example_xs.to(device),\n",
    "                    \"example_ys\": example_delta_xs.to(device),\n",
    "                    \"query_xs\": query_xs.to(device),\n",
    "                    \"query_ys\": delta_xs.to(device),\n",
    "                    \"mu\": mus.to(device),  # NOTE: mu is only used for plotting.\n",
    "                    }\n",
    "    else:\n",
    "        # samples uniformly from the input space, then takes one step\n",
    "        n_datapoints = 1000\n",
    "        # Generate a trajectory of example data for each mu\n",
    "        example_xs = torch.rand(n_functions, n_datapoints, 2, device=device) * (input_high - input_low) + input_low\n",
    "        query_xs = torch.rand(n_functions, n_datapoints, 2, device=device) * (input_high - input_low) + input_low\n",
    "\n",
    "        # compute next state\n",
    "        example_ys = rk4_delta_only(lambda x: vanderpol(x, mus), example_xs, dt)\n",
    "        query_ys = rk4_delta_only(lambda x: vanderpol(x, mus), query_xs, dt)\n",
    "\n",
    "        dataset = {\"example_xs\": example_xs,\n",
    "                   \"example_ys\": example_ys,\n",
    "                   \"query_xs\": query_xs,\n",
    "                   \"query_ys\": query_ys,\n",
    "                   \"mu\": mus.to(device),  # NOTE: mu is only used for plotting.\n",
    "                   }\n",
    "\n",
    "    return dataset\n",
    "\n",
    "# Create dataset\n",
    "train_dataset = create_dataset(device, generate_trajectory=False) # Change this to True for a harder setting!\n",
    "test_dataset = create_dataset(device, generate_trajectory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As is usual, let's wrap these for NeuroMancer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wrap data into Neuromancer DictDatasets\n",
    "train_data = DictDataset(train_dataset, name='train')\n",
    "dev_data = DictDataset(test_dataset, name='dev')\n",
    "\n",
    "# Create torch dataloaders with DictDatasets\n",
    "train_loader = torch.utils.data.DataLoader(train_data, batch_size=10,\n",
    "                                           collate_fn=train_data.collate_fn,\n",
    "                                           shuffle=False)\n",
    "dev_loader = torch.utils.data.DataLoader(dev_data, batch_size=10,\n",
    "                                         collate_fn=dev_data.collate_fn,\n",
    "                                         shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's define the basis functions. Again, we will use RK4 as the integrator. One important detail is that this integrator outputs the CHANGE in state, rather than the next state directly. This is a more convenient form for the function encoder. For the sake of brevity, I won't go into it here, but see the methods section in [\"Zero-Shot Transfer of Neural ODEs\" (NeurIPS 2024)](https://arxiv.org/abs/2405.08954) if you are curious about these details.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize basis functions networks\n",
    "n_basis = 11\n",
    "basis_functions = [\n",
    "    blocks.MLP(2, 2,\n",
    "                 linear_map=torch.nn.Linear,\n",
    "                 nonlin=torch.nn.ReLU,\n",
    "                 hsizes=[100]).to(device)\n",
    "    for i in range(n_basis)]\n",
    "\n",
    "# use an integrator to make them neural ODEs\n",
    "# Note this integrator outputs the change in state, not the next state\n",
    "class RK4_delta_only(Integrator):\n",
    "    def __init__(self, block, interp_u=None, h=1.0):\n",
    "        \"\"\"\n",
    "\n",
    "        :param block: (nn.Module) A state transition model.\n",
    "        :param h: (float) integration step size\n",
    "        \"\"\"\n",
    "        super().__init__(block=block, interp_u=interp_u, h=h)\n",
    "\n",
    "    def integrate(self, x, *args):\n",
    "        h = self.h\n",
    "        k1 = self.block(x, *args)                    # k1 = f(x_i, t_i)\n",
    "        k2 = self.block(x + h*k1/2.0, *args)         # k2 = f(x_i + 0.5*h*k1, t_i + 0.5*h)\n",
    "        k3 = self.block(x + h*k2/2.0, *args)         # k3 = f(x_i + 0.5*h*k2, t_i + 0.5*h)\n",
    "        k4 = self.block(x + h*k3, *args)             # k4 = f(y_i + h*k3, t_i + h)\n",
    "        return h*(k1/6.0 + k2/3.0 + k3/3.0 + k4/6.0)\n",
    "basis_functions = [RK4_delta_only(f, h=dt) for f in basis_functions]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the residuals method. The residuals method additionally trains a residual function, which models the average function in the dataset. Then, the basis functions only need to correct the error of this average function, which is often a much easier task than modeling the function itself. The residuals method tends to perform well on dynamical systems, so let's use it here. See [Function Encoders: A Principled Approach to Transfer Learning in Hilbert Spaces](https://arxiv.org/pdf/2501.18373), appendix E for more information. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "residual_function = RK4_delta_only(\n",
    "    blocks.MLP(2, 2,\n",
    "    linear_map=torch.nn.Linear,\n",
    "    nonlin=torch.nn.ReLU,\n",
    "    hsizes=[100]).to(device)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function encoder algorithm only requires trainable basis functions, so it naturally accepts neural ODEs. The forward method of the function encoder takes three inputs: \"example_xs\", \"example_ys\", and \"query_xs\". The example data is used to compute the coefficients of the basis functions, and then the model estimates the \"query_ys\" as a linear combination of the basis functions. As these are just estimates, they are labeled as \"query_y_hats\". It also outputs the Gram matrix, which is useful for regularization.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# the function encoder class provides convenient methods to calibrate estimates using least squares\n",
    "# specifically, it uses example data to compute the coefficients of the basis functions,\n",
    "# then uses a linear combination of the basis functions to estimate the function\n",
    "function_encoder = FunctionEncoder(basis_functions, residual_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also wrap the function encoder into the neuromancer interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Symbolic wrapper of the neural nets\n",
    "function_encoder = Node(function_encoder, ['example_xs', 'example_ys', 'query_xs'], ['query_y_hats', 'gram'], name='function_encoder')\n",
    "\n",
    "# Define symbolic variables in Neuromancer\n",
    "# these are the variables used in the loss functions\n",
    "query_y_hats = variable('query_y_hats')\n",
    "query_ys = variable('query_ys')\n",
    "gram = variable('gram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's define the loss function. These are exactly the same as in the previous example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the losses\n",
    "# The first ensures the function estimates align with the true function\n",
    "loss_data = (query_y_hats == query_ys)^2\n",
    "loss_data.name = \"loss_data\"\n",
    "\n",
    "# this prevents the magnitude of the basis functions from growing\n",
    "loss_gram = (torch.diagonal(gram, dim1=1, dim2=2) == torch.ones_like(torch.diagonal(gram, dim1=1, dim2=2)))^2\n",
    "loss_gram.name = \"loss_gram\"\n",
    "\n",
    "# add the two losses together\n",
    "loss = PenaltyLoss(objectives=[loss_data, loss_gram], constraints=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to train. Note that this is going to take a few minutes because there are many neural ODEs being run in sequence. In practice, these are run in parallel which greatly speeds things up at the cost of memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0  train_loss: 1.0183324813842773\n",
      "epoch: 10  train_loss: 0.0026478825602680445\n",
      "epoch: 20  train_loss: 0.0017495184438303113\n",
      "epoch: 30  train_loss: 0.0012695981422439218\n",
      "epoch: 40  train_loss: 0.0009677116177044809\n",
      "epoch: 50  train_loss: 0.0007565424311906099\n",
      "epoch: 60  train_loss: 0.0006001807632856071\n",
      "epoch: 70  train_loss: 0.0004917400074191391\n",
      "epoch: 80  train_loss: 0.0004144027770962566\n",
      "epoch: 90  train_loss: 0.00035880133509635925\n",
      "epoch: 100  train_loss: 0.00031566928373649716\n",
      "epoch: 110  train_loss: 0.00028037361335009336\n",
      "epoch: 120  train_loss: 0.0002505594748072326\n",
      "epoch: 130  train_loss: 0.00022545385581906885\n",
      "epoch: 140  train_loss: 0.00020359792688395828\n",
      "epoch: 150  train_loss: 0.0001833374408306554\n",
      "epoch: 160  train_loss: 0.00016531243454664946\n",
      "epoch: 170  train_loss: 0.00014880990784149617\n",
      "epoch: 180  train_loss: 0.00013344510807655752\n",
      "epoch: 190  train_loss: 0.00011943207937292755\n"
     ]
    }
   ],
   "source": [
    "# Construct the optimization problems\n",
    "problem = Problem(nodes=[function_encoder], loss=loss)\n",
    "\n",
    "\n",
    "# Create trainer\n",
    "num_epochs = 200\n",
    "trainer = Trainer(\n",
    "    problem.to(device),\n",
    "    train_data=train_loader,\n",
    "    dev_data=dev_loader,\n",
    "    optimizer=torch.optim.Adam(problem.parameters(), lr=1e-3),\n",
    "    epoch_verbose=10,\n",
    "    epochs=num_epochs,\n",
    "    warmup=num_epochs,\n",
    "    device=device,\n",
    ")\n",
    "\n",
    "\n",
    "# Train function encoder\n",
    "best_model = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Rolling out trajectory: 100%|██████████| 999/999 [00:01<00:00, 525.69it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# # get best model\n",
    "problem.load_state_dict(best_model)\n",
    "trained_model = problem.nodes[0]\n",
    "trained_model = trained_model.callable\n",
    "\n",
    "# estimate outputs and plot.\n",
    "with torch.no_grad():\n",
    "    example_xs, example_ys, query_xs, query_ys, mus = test_dataset[\"example_xs\"], test_dataset[\"example_ys\"], test_dataset[\"query_xs\"], test_dataset[\"query_ys\"], test_dataset[\"mu\"]\n",
    "    fig, axs = plt.subplots(3,3, figsize=(15,10))\n",
    "    coefficients, gram = trained_model.compute_representation(example_xs, example_ys)\n",
    "\n",
    "    # rollout a trajectory starting from the first query xs for each environment\n",
    "    estimated_states = [query_xs[:, 0:1, :]]\n",
    "    for i in trange(1, query_xs.shape[1], desc=\"Rolling out trajectory\"):\n",
    "        current_state = estimated_states[-1]\n",
    "        delta_X = trained_model.predict(current_state, coefficients)\n",
    "        new_state = current_state + delta_X\n",
    "        estimated_states.append(new_state)\n",
    "    estimated_states = torch.cat(estimated_states, dim=1)\n",
    "\n",
    "\n",
    "    for i in range(9):\n",
    "        ax = axs[i//3, i%3]\n",
    "        # plot the ground truth van der pol\n",
    "        ax.plot(query_xs[i, :, 0].cpu().numpy(), query_xs[i, :, 1].cpu().numpy(), label=\"Ground truth\", color=\"black\", ls=\"--\")\n",
    "\n",
    "        # plot the estimated van der pol\n",
    "        ax.plot(estimated_states[i, :, 0].cpu().numpy(), estimated_states[i, :, 1].cpu().numpy(), label=\"Estimated\", color=\"red\")\n",
    "\n",
    "        # add labels\n",
    "        if i == 0:\n",
    "            ax.legend()\n",
    "        if i % 3 == 0:\n",
    "            ax.set_ylabel(\"$x_2$\")\n",
    "        if i // 3 == 2:\n",
    "            ax.set_xlabel(\"$x_1$\")\n",
    "\n",
    "        # add mu as title\n",
    "        mu = mus[i].cpu().item()\n",
    "        ax.set_title(f\"$\\mu = {mu:.1f}$\")\n",
    "\n",
    "        # set lims\n",
    "        ax.set_xlim([-4, 4])\n",
    "        ax.set_ylim([-5, 5])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the residual function, to see if it learned something interesting. It should look approximately like a Van der Pol system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Rolling out trajectory: 100%|██████████| 999/999 [00:00<00:00, 4919.76it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# estimate outputs and plot.\n",
    "with torch.no_grad():\n",
    "    _, _, query_xs, query_ys, mus = test_dataset[\"example_xs\"], test_dataset[\"example_ys\"], test_dataset[\"query_xs\"], test_dataset[\"query_ys\"], test_dataset[\"mu\"]\n",
    "    fig, ax = plt.subplots(1,1, figsize=(10,10))\n",
    "\n",
    "    # rollout a trajectory starting from the first query xs for each environment\n",
    "    estimated_states = [query_xs[:, 0:1, :]]\n",
    "    for i in trange(1, query_xs.shape[1], desc=\"Rolling out trajectory\"):\n",
    "        current_state = estimated_states[-1]\n",
    "        delta_X = trained_model.forward_average_function(current_state)\n",
    "        new_state = current_state + delta_X\n",
    "        estimated_states.append(new_state)\n",
    "    estimated_states = torch.cat(estimated_states, dim=1)\n",
    "\n",
    "    # plot the residual/average function\n",
    "    ax.plot(estimated_states[i, :, 0].cpu().numpy(), estimated_states[i, :, 1].cpu().numpy(), label=\"Estimated\", color=\"red\")\n",
    "\n",
    "    # set lims\n",
    "    ax.set_xlim([-4, 4])\n",
    "    ax.set_ylim([-5, 5])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
